home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 476-500 / disk_496 / memmometer / mminit.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  28KB  |  799 lines
  1. /* : ai=0 bk=0 ts=8 */
  2. #include "mm.h"
  3.  
  4. #define PROJMAX 3               /* number of project menu items */
  5. #define SETUPMAX 2              /* number of setup menu items */
  6. #define MODEMAX 2
  7. #define FREQMAX 4               /* number of frequency menu items */
  8. #define PRIOMAX 16              /* number of priority menu items */
  9. #define CHIPMAX 5               /* number of chip mem size menu items */
  10. #define CHIPAMAX 6              /* number of chip mem base addr menu items */
  11. #define SFMAX 11                /* number of sf mem size menu items */
  12. #define SFAMAX 16               /* number of sf mem base addr menu items */
  13. #define FASTMAX 16              /* number of fast mem size menu items */
  14. #define FASTAMAX 16             /* number of fast mem base addr menu items */
  15. #define MAXMENU 9               /* total number of top level menus */
  16.  
  17. extern BOOL p_mode;             /* preset frags mode = 0, warps mode = 1 */
  18. extern long p_rate;             /* preset sample interval, secs see menu */
  19. extern long p_priority;         /* preset priority, range -100 to +100   */
  20. extern long p_chip;             /* preset chip mem size, kbytes see menu */
  21. extern long p_chipa;            /* preset chip mem address, kb  see menu */
  22. extern long p_sf;               /* preset slowfast mem size, kb see menu */
  23. extern long p_sfa;              /* preset slowfast mem addr, kb see menu */
  24. extern long p_fast;             /* preset fast mem size, mbytes see menu */
  25. extern long p_fasta;            /* preset fast mem addr, mbytes see menu */
  26.  
  27. /******************************************************/
  28. /*    Structure declarations for the menu sections    */
  29. /******************************************************/
  30.  
  31. struct   MenuItem ProjItem[PROJMAX];
  32. struct   IntuiText ProjText[PROJMAX];
  33. struct   MenuItem SetupItem[SETUPMAX];
  34. struct   IntuiText SetupText[SETUPMAX];
  35. struct   MenuItem ModeItem[MODEMAX];
  36. struct   IntuiText ModeText[MODEMAX];
  37. struct   MenuItem FreqItem[FREQMAX];
  38. struct   IntuiText FreqText[FREQMAX];
  39. struct   MenuItem PrioItem[PRIOMAX];
  40. struct   IntuiText PrioText[PRIOMAX];
  41. struct   MenuItem ChipItem[CHIPMAX];
  42. struct   IntuiText ChipText[CHIPMAX];
  43. struct   MenuItem ChipAItem[CHIPAMAX];
  44. struct   IntuiText ChipAText[CHIPAMAX];
  45. struct   MenuItem SFItem[SFMAX];
  46. struct   IntuiText SFText[SFMAX];
  47. struct   MenuItem SFAItem[SFAMAX];
  48. struct   IntuiText SFAText[SFAMAX];
  49. struct   MenuItem FastItem[FASTMAX];
  50. struct   IntuiText FastText[FASTMAX];
  51. struct   MenuItem FastAItem[FASTAMAX];
  52. struct   IntuiText FastAText[FASTAMAX];
  53. struct   Menu menu[MAXMENU];
  54.  
  55. /*****************************************************************/
  56. /*    The following function initializes the structure arrays    */
  57. /*    needed to provide the Project menu topic.                  */
  58. /*    this was left retro-compatible with Manx 3.4a (nplus1)     */
  59. /*****************************************************************/
  60. void InitProjItems()
  61.     {
  62.     int       n,nplus1;
  63.  
  64. /* initialize each menu item and IntuiText with loop */
  65. for( n=0; n<PROJMAX; n++ )
  66.     {
  67.     nplus1 = n + 1;
  68.     ProjItem[n].NextItem = &ProjItem[nplus1];
  69.     ProjItem[n].LeftEdge = 0;
  70.     ProjItem[n].TopEdge = 9 * n;
  71.     ProjItem[n].Width = 64;
  72.     ProjItem[n].Height = 9;
  73.     ProjItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP;
  74.     ProjItem[n].MutualExclude = 0;
  75.     ProjItem[n].ItemFill = (APTR)&ProjText[n];
  76.     ProjItem[n].SelectFill = NULL;
  77.     ProjItem[n].Command = 0;
  78.     ProjItem[n].SubItem = NULL;
  79.     ProjItem[n].NextSelect = 0;
  80.  
  81.     ProjText[n].FrontPen = BLUP;
  82.     ProjText[n].BackPen = WHTP;
  83.     ProjText[n].DrawMode = JAM2;/* render in fore and background */
  84.     ProjText[n].LeftEdge = 0;
  85.     ProjText[n].TopEdge = 1;
  86.     ProjText[n].ITextFont = NULL;
  87.     ProjText[n].NextText = NULL;
  88.     }
  89. ProjItem[PROJMAX-1].NextItem = NULL;
  90.  
  91. /* initialize text for specific menu items */
  92.  
  93. ProjText[0].IText = (UBYTE *)"Front";
  94. ProjText[1].IText = (UBYTE *)"Back";
  95. ProjText[2].IText = (UBYTE *)"Quit";
  96. }
  97.  
  98. /*****************************************************************/
  99. /*    The following initializes the structure arrays             */
  100. /*   needed to provide the Setup menu topic.                     */
  101. /*****************************************************************/
  102.  
  103. void InitSetupItems()
  104.     {
  105.     int       n,nplus1;
  106.  
  107. /* initialize each menu item and IntuiText with loop */
  108. for( n=0; n<SETUPMAX; n++ )
  109.     {
  110.     nplus1 = n + 1;
  111.     SetupItem[n].NextItem = &SetupItem[nplus1];
  112.     SetupItem[n].LeftEdge = 0;
  113.     SetupItem[n].TopEdge = 9 * n;
  114.     SetupItem[n].Width = 44;
  115.     SetupItem[n].Height = 9;
  116.     SetupItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP ;
  117.     SetupItem[n].MutualExclude = 0;
  118.     SetupItem[n].ItemFill = (APTR)&SetupText[n];
  119.     SetupItem[n].SelectFill = NULL;
  120.     SetupItem[n].Command = 0;
  121.     SetupItem[n].NextSelect = 0;
  122.  
  123.     SetupText[n].FrontPen = BLUP;
  124.     SetupText[n].BackPen = WHTP;
  125.     SetupText[n].DrawMode = JAM2;    
  126.     SetupText[n].LeftEdge = 0;
  127.     SetupText[n].TopEdge = 1;
  128.     SetupText[n].ITextFont = NULL;
  129.     SetupText[n].NextText = NULL;
  130.     }
  131. SetupItem[SETUPMAX-1].NextItem = NULL;
  132.  
  133. SetupText[0].IText = (UBYTE *)"Mode";
  134. SetupItem[0].SubItem = ModeItem;
  135. SetupText[1].IText = (UBYTE *)"Freq";
  136. SetupItem[1].SubItem = FreqItem;
  137.  
  138. /*****************************************************************/
  139. /*    The following initializes the structure arrays             */
  140. /*   needed to provide the Mode submenu topic.                   */
  141. /*****************************************************************/
  142.  
  143. for( n=0; n<MODEMAX; n++ )
  144.     {
  145.     nplus1 = n + 1;
  146.     ModeItem[n].NextItem = &ModeItem[nplus1];
  147.     ModeItem[n].LeftEdge = 38;
  148.     ModeItem[n].TopEdge = 9 * n;
  149.     ModeItem[n].Width = 72;
  150.     ModeItem[n].Height = 9;
  151.     ModeItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  152.     ModeItem[n].MutualExclude = (~(1 << n));
  153.     ModeItem[n].ItemFill = (APTR)&ModeText[n];
  154.     ModeItem[n].SelectFill = NULL;
  155.     ModeItem[n].Command = 0;
  156.     ModeItem[n].SubItem = NULL;
  157.     ModeItem[n].NextSelect = 0;
  158.  
  159.     ModeText[n].FrontPen = BLUP;
  160.     ModeText[n].BackPen = WHTP;
  161.     ModeText[n].DrawMode = JAM2;     /* render in fore and background */
  162.     ModeText[n].LeftEdge = 0;
  163.     ModeText[n].TopEdge = 1;
  164.     ModeText[n].ITextFont = NULL;
  165.     ModeText[n].NextText = NULL;
  166.     }
  167. ModeItem[MODEMAX-1].NextItem = NULL;
  168.  
  169. /* select mode subitem checked */
  170. switch (p_mode) {
  171.     case 0:     n = 0; break;
  172.     case 1:     n = 1; break;
  173.     default:    n = 1; p_mode = FALSE;
  174.     }
  175. ModeItem[n].Flags |= CHECKED;
  176.  
  177. /* initialize text for specific submenu items */
  178. ModeText[0].IText = (UBYTE *)"   Frags";
  179. ModeText[1].IText = (UBYTE *)"   Warps";
  180.  
  181. /*****************************************************************/
  182. /*    The following initializes the structure arrays             */
  183. /*   needed to provide the Freq submenu topic.                   */
  184. /*****************************************************************/
  185.  
  186. for( n=0; n<FREQMAX; n++ )
  187.     {
  188.     nplus1 = n + 1;
  189.     FreqItem[n].NextItem = &FreqItem[nplus1];
  190.     FreqItem[n].LeftEdge = 38;
  191.     FreqItem[n].TopEdge = 9 * n;
  192.     FreqItem[n].Width = 88;
  193.     FreqItem[n].Height = 9;
  194.     FreqItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  195.     FreqItem[n].MutualExclude = (~(1 << n));
  196.     FreqItem[n].ItemFill = (APTR)&FreqText[n];
  197.     FreqItem[n].SelectFill = NULL;
  198.     FreqItem[n].Command = 0;
  199.     FreqItem[n].SubItem = NULL;
  200.     FreqItem[n].NextSelect = 0;
  201.  
  202.     FreqText[n].FrontPen = BLUP;
  203.     FreqText[n].BackPen = WHTP;
  204.     FreqText[n].DrawMode = JAM2;     /* render in fore and background */
  205.     FreqText[n].LeftEdge = 0;
  206.     FreqText[n].TopEdge = 1;
  207.     FreqText[n].ITextFont = NULL;
  208.     FreqText[n].NextText = NULL;
  209.     }
  210. FreqItem[FREQMAX-1].NextItem = NULL;
  211.  
  212. /* select frequency item checked */
  213. switch (p_rate) {
  214.     case 1:     n = 0; break;
  215.     case 2:     n = 1; break;
  216.     case 5:     n = 2; break;
  217.     case 10:    n = 3; break;
  218.     default:    n = 1; p_rate = 2;
  219.     }
  220. FreqItem[n].Flags |= CHECKED;
  221.  
  222. /* initialize text for specific menu items */
  223. FreqText[0].IText = (UBYTE *)"    1 Sec ";
  224. FreqText[1].IText = (UBYTE *)"    2 Secs";
  225. FreqText[2].IText = (UBYTE *)"    5 Secs";
  226. FreqText[3].IText = (UBYTE *)"   10 Secs";
  227. }
  228.  
  229. /*****************************************************************/
  230. /*    The following initializes the structure arrays             */
  231. /*   needed to provide the Priority menu topic.                  */
  232. /*****************************************************************/
  233.  
  234. void InitPrioItems()
  235.     {
  236.     int       n,nplus1;
  237.  
  238. /* initialize each menu item and IntuiText with loop */
  239. for( n=0; n<PRIOMAX; n++ )
  240.     {
  241.     nplus1 = n + 1;
  242.     PrioItem[n].NextItem = &PrioItem[nplus1];
  243.     PrioItem[n].LeftEdge = 0;
  244.     PrioItem[n].TopEdge = 9 * n;
  245.     PrioItem[n].Width = 80;
  246.     PrioItem[n].Height = 9;
  247.     PrioItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  248.     PrioItem[n].MutualExclude = (~(1 << n));
  249.     if (n < 3)  PrioItem[n].MutualExclude &= 0x0007;
  250.     if (n < 1)  PrioItem[n].MutualExclude |= 0x0007;
  251.     PrioItem[n].ItemFill = (APTR)&PrioText[n];
  252.     PrioItem[n].SelectFill = NULL;
  253.     PrioItem[n].Command = 0;
  254.     PrioItem[n].NextSelect = 0;
  255.  
  256.     PrioText[n].FrontPen = BLUP;
  257.     PrioText[n].BackPen = WHTP;
  258.     if (n > 11)  {
  259.         PrioText[n].FrontPen = ORNP;
  260.         PrioText[n].BackPen = REDP;
  261.         }
  262.     PrioText[n].DrawMode = JAM2;    
  263.     PrioText[n].LeftEdge = 0;
  264.     PrioText[n].TopEdge = 1;
  265.     PrioText[n].ITextFont = NULL;
  266.     PrioText[n].NextText = NULL;
  267.     }
  268. PrioItem[PRIOMAX-1].NextItem = NULL;
  269.  
  270. /* select priority item checked */
  271. switch (p_priority) {
  272.     case  -99:     n =  3; break;
  273.     case  -75:     n =  4; break;
  274.     case  -50:     n =  5; break;
  275.     case  -25:     n =  6; break;
  276.     case  -20:     n =  7; break;
  277.     case  -15:     n =  8; break;
  278.     case  -10:     n =  9; break;
  279.     case   -5:     n = 10; break;
  280.     case    0:     n = 11; break;
  281.     case    5:     n = 12; break;
  282.     case   10:     n = 13; break;
  283.     case   15:     n = 14; break;
  284.     case   20:     n = 15; break;
  285.     default:       n = 11; p_priority = 0;
  286.     }
  287. PrioItem[n].Flags |= CHECKED;
  288.  
  289. PrioText[ 0].IText = (UBYTE *)"   NORM   ";
  290. PrioText[ 1].IText = (UBYTE *)"   DECR   ";
  291. PrioText[ 2].IText = (UBYTE *)"   INCR   ";
  292. PrioText[ 3].IText = (UBYTE *)"   -99    ";
  293. PrioText[ 4].IText = (UBYTE *)"   -75    ";
  294. PrioText[ 5].IText = (UBYTE *)"   -50    ";
  295. PrioText[ 6].IText = (UBYTE *)"   -25    ";
  296. PrioText[ 7].IText = (UBYTE *)"   -20    ";
  297. PrioText[ 8].IText = (UBYTE *)"   -15    ";
  298. PrioText[ 9].IText = (UBYTE *)"   -10    ";
  299. PrioText[10].IText = (UBYTE *)"   -5     ";
  300. PrioText[11].IText = (UBYTE *)"    0     ";
  301. PrioText[12].IText = (UBYTE *)"    5     ";
  302. PrioText[13].IText = (UBYTE *)"    10    ";
  303. PrioText[14].IText = (UBYTE *)"    15    ";
  304. PrioText[15].IText = (UBYTE *)"    20    ";
  305. }
  306.  
  307. /*****************************************************************/
  308. /*    The following initializes the structure arrays             */
  309. /*   needed to provide the Chip Mem Size menu topic.             */
  310. /*****************************************************************/
  311.  
  312. void InitChipItems()
  313.     {
  314.     int       n,nplus1;
  315.  
  316. /* initialize each menu item and IntuiText with loop */
  317. for( n=0; n<CHIPMAX; n++ )
  318.     {
  319.     nplus1 = n + 1;
  320.     ChipItem[n].NextItem = &ChipItem[nplus1];
  321.     ChipItem[n].LeftEdge = 0;
  322.     ChipItem[n].TopEdge = 9 * n;
  323.     ChipItem[n].Width = 80;
  324.     ChipItem[n].Height = 9;
  325.     ChipItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  326.     ChipItem[n].MutualExclude = (~(1 << n));
  327.     ChipItem[n].ItemFill = (APTR)&ChipText[n];
  328.     ChipItem[n].SelectFill = NULL;
  329.     ChipItem[n].Command = 0;
  330.     ChipItem[n].NextSelect = 0;
  331.  
  332.     ChipText[n].FrontPen = BLUP;
  333.     ChipText[n].BackPen = WHTP;
  334.     ChipText[n].DrawMode = JAM2;    
  335.     ChipText[n].LeftEdge = 0;
  336.     ChipText[n].TopEdge = 1;
  337.     ChipText[n].ITextFont = NULL;
  338.     ChipText[n].NextText = NULL;
  339.     }
  340. ChipItem[CHIPMAX-1].NextItem = NULL;
  341.  
  342. /* select chip mem size item checked */
  343. switch (p_chip) {
  344.     case    0:     n = 0; break;
  345.     case  256:     n = 1; break;
  346.     case  512:     n = 2; break;
  347.     case 1024:     n = 3; break;
  348.     case 2048:     n = 4; break;
  349.     default:       n = 2; p_chip = 512;
  350.     }
  351. ChipItem[n].Flags |= CHECKED;
  352.  
  353. ChipText[0].IText = (UBYTE *)"   NONE";
  354. ChipText[1].IText = (UBYTE *)"   256K";
  355. ChipText[2].IText = (UBYTE *)"   512K";
  356. ChipText[3].IText = (UBYTE *)"   1 MB";
  357. ChipText[4].IText = (UBYTE *)"   2 MB";
  358. }
  359.  
  360. /*****************************************************************/
  361. /*    The following initializes the structure arrays             */
  362. /*   needed to provide the Chip Base Addr menu topic.            */
  363. /*****************************************************************/
  364.  
  365. void InitChipAItems()
  366.     {
  367.     int       n,nplus1;
  368.  
  369. /* initialize each menu item and IntuiText with loop */
  370. for( n=0; n<CHIPAMAX; n++ )
  371.     {
  372.     nplus1 = n + 1;
  373.     ChipAItem[n].NextItem = &ChipAItem[nplus1];
  374.     ChipAItem[n].LeftEdge = 0;
  375.     ChipAItem[n].TopEdge = 9 * n;
  376.     ChipAItem[n].Width = 80;
  377.     ChipAItem[n].Height = 9;
  378.     ChipAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  379.     ChipAItem[n].MutualExclude = (~(1 << n));
  380.     ChipAItem[n].ItemFill = (APTR)&ChipAText[n];
  381.     ChipAItem[n].SelectFill = NULL;
  382.     ChipAItem[n].Command = 0;
  383.     ChipAItem[n].NextSelect = 0;
  384.  
  385.     ChipAText[n].FrontPen = BLUP;
  386.     ChipAText[n].BackPen = WHTP;
  387.     ChipAText[n].DrawMode = JAM2;    
  388.     ChipAText[n].LeftEdge = 0;
  389.     ChipAText[n].TopEdge = 1;
  390.     ChipAText[n].ITextFont = NULL;
  391.     ChipAText[n].NextText = NULL;
  392.     }
  393. ChipAItem[CHIPAMAX-1].NextItem = NULL;
  394.  
  395. /* select chip base address item checked */
  396. switch (p_chipa) {
  397.     case    0:     n = 0; break;
  398.     case  256:     n = 1; break;
  399.     case  512:     n = 2; break;
  400.     case  768:     n = 3; break;
  401.     case 1024:     n = 4; break;
  402.     case 1536:     n = 5; break;
  403.     default:       n = 0; p_chipa = 0;
  404.     }
  405. ChipAItem[n].Flags |= CHECKED;
  406.  
  407. ChipAText[0].IText = (UBYTE *)"   @   0K";
  408. ChipAText[1].IText = (UBYTE *)"   @ 256K";
  409. ChipAText[2].IText = (UBYTE *)"   @ 512K";
  410. ChipAText[3].IText = (UBYTE *)"   @ 768K";
  411. ChipAText[4].IText = (UBYTE *)"   @ 1.0M";
  412. ChipAText[5].IText = (UBYTE *)"   @ 1.5M";
  413. }
  414.  
  415. /*****************************************************************/
  416. /*    The following initializes the structure arrays             */
  417. /*   needed to provide the Slow Fast Mem Size menu topic.        */
  418. /*****************************************************************/
  419.  
  420. void InitSFItems()
  421.     {
  422.     int       n,nplus1;
  423.  
  424. /* initialize each menu item and IntuiText with loop */
  425. for( n=0; n<SFMAX; n++ )
  426.     {
  427.     nplus1 = n + 1;
  428.     SFItem[n].NextItem = &SFItem[nplus1];
  429.     SFItem[n].LeftEdge = 0;
  430.     SFItem[n].TopEdge = 9 * n;
  431.     SFItem[n].Width = 80;
  432.     SFItem[n].Height = 9;
  433.     SFItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  434.     SFItem[n].MutualExclude = (~(1 << n));
  435.     SFItem[n].ItemFill = (APTR)&SFText[n];
  436.     SFItem[n].SelectFill = NULL;
  437.     SFItem[n].Command = 0;
  438.     SFItem[n].NextSelect = 0;
  439.  
  440.     SFText[n].FrontPen = BLUP;
  441.     SFText[n].BackPen = WHTP;
  442.     SFText[n].DrawMode = JAM2;    
  443.     SFText[n].LeftEdge = 0;
  444.     SFText[n].TopEdge = 1;
  445.     SFText[n].ITextFont = NULL;
  446.     SFText[n].NextText = NULL;
  447.     }
  448. SFItem[SFMAX-1].NextItem = NULL;
  449.  
  450. /* select slow fast mem size item checked */
  451. switch (p_sf) {
  452.     case    0:      n = 0;  break;
  453.     case  256:      n = 1;  break;
  454.     case  512:      n = 2;  break;
  455.     case  768:      n = 3;  break;
  456.     case 1024:      n = 4;  break;
  457.     case 1536:      n = 5;  break;
  458.     case 2048:      n = 6;  break;
  459.     case 3072:      n = 7;  break;
  460.     case 4096:      n = 8;  break;
  461.     case 6144:      n = 9;  break;
  462.     case 8192:      n = 10; break;
  463.     default:        n = 0;  p_sf = 0;
  464.     }
  465. SFItem[n].Flags |= CHECKED;
  466.  
  467. SFText[ 0].IText = (UBYTE *)"   NONE  ";
  468. SFText[ 1].IText = (UBYTE *)"   .25 MB";
  469. SFText[ 2].IText = (UBYTE *)"   .5  MB";
  470. SFText[ 3].IText = (UBYTE *)"   .75 MB";
  471. SFText[ 4].IText = (UBYTE *)"   1.0 MB";
  472. SFText[ 5].IText = (UBYTE *)"   1.5 MB";
  473. SFText[ 6].IText = (UBYTE *)"   2.0 MB";
  474. SFText[ 7].IText = (UBYTE *)"   3.0 MB";
  475. SFText[ 8].IText = (UBYTE *)"   4.0 MB";
  476. SFText[ 9].IText = (UBYTE *)"   6.0 MB";
  477. SFText[10].IText = (UBYTE *)"   8.0 MB";
  478. }
  479.  
  480. /*****************************************************************/
  481. /*    The following initializes the structure arrays             */
  482. /*   needed to provide the Slow Fast Mem Base Addr menu topic.   */
  483. /*****************************************************************/
  484.  
  485. void InitSFAItems()
  486.     {
  487.     int       n,nplus1;
  488.  
  489. /* initialize each menu item and IntuiText with loop */
  490. for( n=0; n<SFAMAX; n++ )
  491.     {
  492.     nplus1 = n + 1;
  493.     SFAItem[n].NextItem = &SFAItem[nplus1];
  494.     SFAItem[n].LeftEdge = 0;
  495.     SFAItem[n].TopEdge = 9 * n;
  496.     SFAItem[n].Width = 104;
  497.     SFAItem[n].Height = 9;
  498.     SFAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  499.     SFAItem[n].MutualExclude = (~(1 << n));
  500.     SFAItem[n].ItemFill = (APTR)&SFAText[n];
  501.     SFAItem[n].SelectFill = NULL;
  502.     SFAItem[n].Command = 0;
  503.     SFAItem[n].NextSelect = 0;
  504.  
  505.     SFAText[n].FrontPen = BLUP;
  506.     SFAText[n].BackPen = WHTP;
  507.     SFAText[n].DrawMode = JAM2;    
  508.     SFAText[n].LeftEdge = 0;
  509.     SFAText[n].TopEdge = 1;
  510.     SFAText[n].ITextFont = NULL;
  511.     SFAText[n].NextText = NULL;
  512.     }
  513. SFAItem[SFAMAX-1].NextItem = NULL;
  514.  
  515. /* select slow fast mem base address item checked */
  516. switch (p_sfa) {
  517.     case  2048:     n =  0; break;              /* 0x0800 kb =  2    mb */
  518.     case  2304:     n =  1; break;              /* 0x0900 kb =  2.25 mb */
  519.     case  2560:     n =  2; break;              /* 0x0A00 kb =  2.5  mb */
  520.     case  2816:     n =  3; break;              /* 0x0B00 kb =  2.75 mb */
  521.     case  3072:     n =  4; break;              /* 0x0C00 kb =  3    mb */
  522.     case  4096:     n =  5; break;              /* 0x1000 kb =  4    mb */
  523.     case  5120:     n =  6; break;              /* 0x1400 kb =  5    mb */
  524.     case  6144:     n =  7; break;              /* 0x1800 kb =  6    mb */
  525.     case  7168:     n =  8; break;              /* 0x1C00 kb =  7    mb */
  526.     case  8192:     n =  9; break;              /* 0x2000 kb =  8    mb */
  527.     case  9216:     n = 10; break;              /* 0x2400 kb =  9    mb */
  528.     case 12288:     n = 11; break;              /* 0x3000 kb = 12    mb */
  529.     case 12544:     n = 12; break;              /* 0x3100 kb = 12.25 mb */
  530.     case 12800:     n = 13; break;              /* 0x3200 kb = 12.5  mb */
  531.     case 13056:     n = 14; break;              /* 0x3300 kb = 12.75 mb */
  532.     case 13312:     n = 15; break;              /* 0x3400 kb = 13    mb */
  533.     default:        n =  0; p_sfa = 2048;
  534.     }
  535. SFAItem[n].Flags |= CHECKED;
  536.  
  537. SFAText[ 0].IText = (UBYTE *)"   @ 2.0 Meg";
  538. SFAText[ 1].IText = (UBYTE *)"   @ 2.4 Meg";
  539. SFAText[ 2].IText = (UBYTE *)"   @ 2.8 Meg";
  540. SFAText[ 3].IText = (UBYTE *)"   @ 2.C Meg";
  541. SFAText[ 4].IText = (UBYTE *)"   @ 3.0 Meg";
  542. SFAText[ 5].IText = (UBYTE *)"   @ 4.0 Meg";
  543. SFAText[ 6].IText = (UBYTE *)"   @ 5.0 Meg";
  544. SFAText[ 7].IText = (UBYTE *)"   @ 6.0 Meg";
  545. SFAText[ 8].IText = (UBYTE *)"   @ 7.0 Meg";
  546. SFAText[ 9].IText = (UBYTE *)"   @ 8.0 Meg";
  547. SFAText[10].IText = (UBYTE *)"   @ 9.0 Meg";
  548. SFAText[11].IText = (UBYTE *)"   @ C.0 Meg";
  549. SFAText[12].IText = (UBYTE *)"   @ C.4 Meg";
  550. SFAText[13].IText = (UBYTE *)"   @ C.8 Meg";
  551. SFAText[14].IText = (UBYTE *)"   @ C.C Meg";
  552. SFAText[15].IText = (UBYTE *)"   @ D.0 Meg";
  553. }
  554.  
  555. /*****************************************************************/
  556. /*    The following initializes the structure arrays             */
  557. /*   needed to provide the Fast Mem Size menu topic.             */
  558. /*****************************************************************/
  559.  
  560. void InitFastItems()
  561.     {
  562.     int       n,nplus1;
  563.  
  564. /* initialize each menu item and IntuiText with loop */
  565. for( n=0; n<FASTMAX; n++ )
  566.     {
  567.     nplus1 = n + 1;
  568.     FastItem[n].NextItem = &FastItem[nplus1];
  569.     FastItem[n].LeftEdge = 0;
  570.     FastItem[n].TopEdge = 9 * n;
  571.     FastItem[n].Width = 80;
  572.     FastItem[n].Height = 9;
  573.     FastItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  574.     FastItem[n].MutualExclude = (~(1 << n));
  575.     FastItem[n].ItemFill = (APTR)&FastText[n];
  576.     FastItem[n].SelectFill = NULL;
  577.     FastItem[n].Command = 0;
  578.     FastItem[n].NextSelect = 0;
  579.  
  580.     FastText[n].FrontPen = BLUP;
  581.     FastText[n].BackPen = WHTP;
  582.     FastText[n].DrawMode = JAM2;    
  583.     FastText[n].LeftEdge = 0;
  584.     FastText[n].TopEdge = 1;
  585.     FastText[n].ITextFont = NULL;
  586.     FastText[n].NextText = NULL;
  587.     }
  588. FastItem[FASTMAX-1].NextItem = NULL;
  589.  
  590. /* select fast mem size item checked */
  591. switch (p_fast) {
  592.     case   0:       n = 0;  break;
  593.     case 256:       n = 1;  break;
  594.     case 512:       n = 2;  break;
  595.     case 756:       n = 3;  break;
  596.     case   1:       n = 4;  break;
  597.     case   2:       n = 5;  break;
  598.     case   3:       n = 6;  break;
  599.     case   4:       n = 7;  break;
  600.     case   6:       n = 8;  break;
  601.     case   8:       n = 9;  break;
  602.     case  10:       n = 10;  break;
  603.     case  12:       n = 11;  break;
  604.     case  13:       n = 12; break;
  605.     case  14:       n = 13; break;
  606.     case  15:       n = 14; break;
  607.     case  16:       n = 15; break;
  608.     default:        n = 0;  p_fast = 0;
  609.     }
  610. FastItem[n].Flags |= CHECKED;
  611.  
  612. FastText[ 0].IText = (UBYTE *)"   NONE";
  613. FastText[ 1].IText = (UBYTE *)"   256K";
  614. FastText[ 2].IText = (UBYTE *)"   512K";
  615. FastText[ 3].IText = (UBYTE *)"   756K";
  616. FastText[ 4].IText = (UBYTE *)"   1 MB";
  617. FastText[ 5].IText = (UBYTE *)"   2 MB";
  618. FastText[ 6].IText = (UBYTE *)"   3 MB";
  619. FastText[ 7].IText = (UBYTE *)"   4 MB";
  620. FastText[ 8].IText = (UBYTE *)"   6 MB";
  621. FastText[ 9].IText = (UBYTE *)"   8 MB";
  622. FastText[10].IText = (UBYTE *)"  10 MB";
  623. FastText[11].IText = (UBYTE *)"  12 MB";
  624. FastText[12].IText = (UBYTE *)"  13 MB";
  625. FastText[13].IText = (UBYTE *)"  14 MB";
  626. FastText[14].IText = (UBYTE *)"  15 MB";
  627. FastText[15].IText = (UBYTE *)"  16 MB";
  628. }
  629.  
  630. /*****************************************************************/
  631. /*    The following initializes the structure arrays             */
  632. /*   needed to provide the Fast Mem Base Addr menu topic.        */
  633. /*****************************************************************/
  634.  
  635. void InitFastAItems()
  636.     {
  637.     int       n,nplus1;
  638.  
  639. /* initialize each menu item and IntuiText with loop */
  640. for( n=0; n<FASTAMAX; n++ )
  641.     {
  642.     nplus1 = n + 1;
  643.     FastAItem[n].NextItem = &FastAItem[nplus1];
  644.     FastAItem[n].LeftEdge = 0;
  645.     FastAItem[n].TopEdge = 9 * n;
  646.     FastAItem[n].Width = 80;
  647.     FastAItem[n].Height = 9;
  648.     FastAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  649.     FastAItem[n].MutualExclude = (~(1 << n));
  650.     FastAItem[n].ItemFill = (APTR)&FastAText[n];
  651.     FastAItem[n].SelectFill = NULL;
  652.     FastAItem[n].Command = 0;
  653.     FastAItem[n].NextSelect = 0;
  654.  
  655.     FastAText[n].FrontPen = BLUP;
  656.     FastAText[n].BackPen = WHTP;
  657.     FastAText[n].DrawMode = JAM2;    
  658.     FastAText[n].LeftEdge = 0;
  659.     FastAText[n].TopEdge = 1;
  660.     FastAText[n].ITextFont = NULL;
  661.     FastAText[n].NextText = NULL;
  662.     }
  663. FastAItem[FASTAMAX-1].NextItem = NULL;
  664.  
  665. /* select fast base address item checked */
  666. switch (p_fasta) {
  667.     case   2:       n = 0;   break;     /* Offset in megs above 0x0000000 */
  668.     case   3:       n = 1;   break;
  669.     case   4:       n = 2;   break;
  670.     case   5:       n = 3;   break;
  671.     case   6:       n = 4;   break;
  672.     case   8:       n = 5;   break;
  673.     case  -1:       n = 6;   break;
  674.     case  -2:       n = 7;   break;
  675.     case  -3:       n = 8;   break;     /* Offset in megs below 0x8000000 */
  676.     case  -4:       n = 9;   break;
  677.     case  -6:       n = 10;  break;
  678.     case  -8:       n = 11;  break;
  679.     case -10:       n = 12;  break;
  680.     case -12:       n = 13;  break;
  681.     case -14:       n = 14;  break;
  682.     case -16:       n = 15;  break;
  683.     default:        n =  6;  p_fasta = -1;
  684.     }
  685. FastAItem[n].Flags |= CHECKED;
  686.  
  687. FastAText[ 0].IText = (UBYTE *)"   @ 2 M";
  688. FastAText[ 1].IText = (UBYTE *)"   @ 3 M";
  689. FastAText[ 2].IText = (UBYTE *)"   @ 4 M";
  690. FastAText[ 3].IText = (UBYTE *)"   @ 5 M";
  691. FastAText[ 4].IText = (UBYTE *)"   @ 6 M";
  692. FastAText[ 5].IText = (UBYTE *)"   @ 8 M";
  693. FastAText[ 6].IText = (UBYTE *)"   @7f M";
  694. FastAText[ 7].IText = (UBYTE *)"   @7e M";
  695. FastAText[ 8].IText = (UBYTE *)"   @7d M";
  696. FastAText[ 9].IText = (UBYTE *)"   @7c M";
  697. FastAText[10].IText = (UBYTE *)"   @7a M";
  698. FastAText[11].IText = (UBYTE *)"   @78 M";
  699. FastAText[12].IText = (UBYTE *)"   @76 M";
  700. FastAText[13].IText = (UBYTE *)"   @74 M";
  701. FastAText[14].IText = (UBYTE *)"   @72 M";
  702. FastAText[15].IText = (UBYTE *)"   @70 M";
  703. }
  704.  
  705. /****************************************************************/
  706. /*   The following function inits the Menu structure array with */
  707. /*  appropriate values for our simple menu.  Review the manual  */
  708. /*  if you need to know what each value means.                  */
  709. /****************************************************************/
  710. void InitMenu()
  711. {
  712. menu[0].NextMenu = &menu[1];
  713. menu[0].LeftEdge = 0;
  714. menu[0].TopEdge = 0;
  715. menu[0].Width = 64;
  716. menu[0].Height = 10;
  717. menu[0].Flags = MENUENABLED;
  718. menu[0].MenuName = "Project";        /* text for menu-bar display */
  719. menu[0].FirstItem = &ProjItem[0];    /* pointer to first item in list */
  720.  
  721. menu[1].NextMenu = &menu[2];
  722. menu[1].LeftEdge = 64;
  723. menu[1].TopEdge = 0;
  724. menu[1].Width = 48;
  725. menu[1].Height = 10;
  726. menu[1].Flags = MENUENABLED;
  727. menu[1].MenuName = "Setup";          /* text for menu-bar display */
  728. menu[1].FirstItem = &SetupItem[0];   /* pointer to first item in list */
  729.  
  730. menu[2].NextMenu = &menu[3];
  731. menu[2].LeftEdge = 112;
  732. menu[2].TopEdge = 0;
  733. menu[2].Width = 72;
  734. menu[2].Height = 10;
  735. menu[2].Flags = MENUENABLED;
  736. menu[2].MenuName = "Priority";       /* text for menu-bar display */
  737. menu[2].FirstItem = &PrioItem[0];    /* pointer to first item in list */
  738.  
  739. menu[3].NextMenu = &menu[4];
  740. menu[3].LeftEdge = 184;
  741. menu[3].TopEdge = 0;
  742. menu[3].Width = 80;
  743. menu[3].Height = 10;
  744. menu[3].Flags = MENUENABLED;
  745. menu[3].MenuName = "Chip Size";      /* text for menu-bar display */
  746. menu[3].FirstItem = &ChipItem[0];    /* pointer to first item in list */
  747.  
  748. menu[4].NextMenu = &menu[5];
  749. menu[4].LeftEdge = 264;
  750. menu[4].TopEdge = 0;
  751. menu[4].Width = 80;
  752. menu[4].Height = 10;
  753. menu[4].Flags = MENUENABLED;
  754. menu[4].MenuName = "Chip Addr";      /* text for menu-bar display */
  755. menu[4].FirstItem = &ChipAItem[0];   /* pointer to first item in list */
  756.  
  757. menu[5].NextMenu = &menu[6];
  758. menu[5].LeftEdge = 344;
  759. menu[5].TopEdge = 0;
  760. menu[5].Width = 64;
  761. menu[5].Height = 10;
  762. menu[5].Flags = MENUENABLED;
  763. menu[5].MenuName = "SF Size";        /* text for menu-bar display */
  764. menu[5].FirstItem = &SFItem[0];      /* pointer to first item in list */
  765.  
  766. menu[6].NextMenu = &menu[7];
  767. menu[6].LeftEdge = 408;
  768. menu[6].TopEdge = 0;
  769. menu[6].Width = 64;
  770. menu[6].Height = 10;
  771. menu[6].Flags = MENUENABLED;
  772. menu[6].MenuName = "SF Addr";        /* text for menu-bar display */
  773. menu[6].FirstItem = &SFAItem[0];     /* pointer to first item in list */
  774.  
  775. menu[7].NextMenu = &menu[8];
  776. menu[7].LeftEdge = 472;
  777. menu[7].TopEdge = 0;
  778. menu[7].Width = 80;
  779. menu[7].Height = 10;
  780. menu[7].Flags = MENUENABLED;
  781. menu[7].MenuName = "Fast Size";      /* text for menu-bar display */
  782. menu[7].FirstItem = &FastItem[0];    /* pointer to first item in list */
  783.  
  784. menu[8].NextMenu = NULL;
  785. menu[8].LeftEdge = 552;
  786. menu[8].TopEdge = 0;
  787. menu[8].Width = 80;
  788. menu[8].Height = 10;
  789. menu[8].Flags = MENUENABLED;
  790. menu[8].MenuName = "Fast Addr";      /* text for menu-bar display */
  791. menu[8].FirstItem = &FastAItem[0];   /* pointer to first item in list */
  792.  
  793. }
  794.  
  795. void StartMenus()
  796. {
  797. SetMenuStrip(window,&menu[0]);
  798. }
  799.